#include <iostream>
#include <cassert>
#include <vector>
#include <tuple>
using namespace std;
#define all(x) (x).begin(), (x).end()
#define ssz(x) (int((x).size()))
auto chmax = [](auto& x, auto y) { if (x < y) x = y; };
auto chmin = [](auto& x, auto y) { if (y < x) x = y; };
using ll = long long;
const int N = 1e6, mod = 998244353;
struct info{
	int mu, imu, ad, zs;
}
tf[N], tf2[N];
int hd[N], des[N * 2], nxt[N * 2], ff[N], f[N], f2[N], g[N], st[N], ed[N], mxd[N], fac[N + 1], ifac[N + 1], ec = 0, ind = 0;
vector<pair<int, int>> buc[N];
vector<pair<int, int>> stk[N], fs[N];
vector<int> tr[N];
void add(int s, int t){
	des[ec] = t;
	nxt[ec] = hd[s];
	hd[s] = ec++;
}
void dfs0(int id, int fa){
	mxd[id] = ff[id] = 1;
	for (int p = hd[id], dst; p != -1; p = nxt[p]){
		dst = des[p];
		if (dst != fa){
			dfs0(dst, id);
			buc[mxd[dst]].emplace_back(id, dst);
			chmax(mxd[id], mxd[dst] + 1);
			ff[id] = 1ll * ff[id] * ff[dst] % mod;
		}
	}
	ff[id] = (ff[id] + 1) % mod;
}
ll qpow(ll bs, ll ix){
	ll mul = bs, ret = 1;
	while (ix){
		if (ix & 1)
			ret = (ret * mul) % mod;
		mul = (mul * mul) % mod;
		ix >>= 1;
	}
	return ret;
}
int recvg(int x, int i, const info& t) {
	return ((i >= t.zs ? 0 : 1ll * t.mu * x) + t.ad) % mod;
}
int recvf(int x, int i, const info& t) {
	return ((i < t.zs ? 0 : 1ll * t.mu * x) + t.ad) % mod;
}
int recv(int x, int i) {
	return recvf(fs[x][i].first, i, tf[x]);
}
void mergef(int id, int x, int lsf, int ilsf){
	if (lsf)
		tf[id].imu = 1ll * tf[id].imu * ilsf % mod;
	for (int i = ssz(fs[x]) - 1, j = ssz(fs[id]) - 1; i >= 0; i--, j--){
		int cv = 1ll * recv(x, i) * recv(id, j) % mod;
		fs[id][j].first = 1ll * (cv - 1ll * tf[id].ad * lsf % mod + mod) * tf[id].imu % mod;
	}
	tf[id].ad = 1ll * tf[id].ad * lsf % mod;
	if (lsf)
		tf[id].mu = 1ll * tf[id].mu * lsf % mod;
	else{
		int dv = ssz(fs[id]) - ssz(fs[x]);
		for (int i = dv; i < ssz(fs[id]); i++)
			fs[id][i].first = recv(id, i);
		tf[id] = { 1, 1, 0, dv };
	}
}
int l;
void dfs1(int id){
	tf[id] = { 1, 1, 0, 0 };
	// cerr << id << endl;
	st[id] = ind++;
	for (auto x : tr[id])
	{
		// cerr << x << " " << id << endl;
		dfs1(x);
		if (fs[id].empty())
		{
			swap(fs[x], fs[id]);
			tf[id] = tf2[x] = tf[x];
			continue;
		}
		mergef(id, x, ff[x], 1ll * ifac[x + 1] * fac[x] % mod);
		int dv = ssz(fs[id]) - ssz(fs[x]);
		for (int i = dv; i < ssz(fs[id]); i++)
			stk[fs[id][i].second].emplace_back(fs[id][i].first, st[x]);
		tf2[x] = tf[id];
	}
	int ev = 1ll * (1 - tf[id].ad + mod) * tf[id].imu % mod;
	fs[id].emplace_back(ev, id);
	stk[id].emplace_back(ev, st[id]);
	(tf[id].ad += 1) %= mod;
	f[id] = recv(id, ssz(fs[id]) - 1 - min(mxd[id] - 1, l));
	if (l > 0)
		f2[id] = recv(id, ssz(fs[id]) - 1 - min(mxd[id] - 1, l - 1));
	ed[id] = ind;
}

void dfs2(int id, vector<pair<int, int>>& gs, info tg)
{
	assert(ssz(gs) == mxd[id]);
	g[id] = recvg(gs.back().first, ssz(gs) - 1, tg);
	gs.pop_back();
	if (gs.empty())
		return;
	int lsf = 1, ilsf = 1;
	for (int i = ssz(tr[id]) - 1; i > 0; i--)
	{
		int x = tr[id][i];
		vector<pair<int, int>> ngs(mxd[x]);
		for (int y = x, j = ssz(ngs) - 1, k = ssz(gs) - 1; y != -1; y = tr[y].empty() ? -1 : tr[y][0], j--, k--)
		{
			ngs[j] = { recvg(gs[k].first, k, tg), y };
			// cerr << id << " " << j << " " << recvg(gs[k].first, k, tg) << endl;
		}
		if (i < ssz(tr[id]) - 1)
		{
			int y = tr[id][i + 1];
			for (int j = ssz(fs[y]) - l + 1, k = ssz(ngs) - 1; k >= 0 && j < ssz(fs[y]); j++, k--)
			{
				ngs[k].first = 1ll * ngs[k].first * recv(y, max(0, j)) % mod;
				// cerr << id << " " << k << " " << recv(y, max(0, j)) << endl;
			}
		}
		int y = tr[id][i - 1];
		// cerr << id << " " << x << " " << y << endl;
		for (int j = max(0, ssz(ngs) - l + 1); j < ssz(ngs); j++)
		{
			int k = max(0, ssz(gs) - (l - (ssz(ngs) - j))), p = gs[k].second;
			// cerr << p << " " << ssz(stk[p]) << endl;
			while (!stk[p].empty() && stk[p].back().second >= ed[y])
				stk[p].pop_back();
			assert(!stk[p].empty());
			int &v = ngs[j].first;
			v = 1ll * v * recvf(stk[p].back().first, k, tf2[y]) % mod;
			// cerr << id << " " << j << " " << recvf(stk[p].back().first, k, tf2[y]) << endl;
		}
		if (ssz(ngs) >= l)
			end(ngs)[-l].first = 1;
		dfs2(x, ngs, { 1, 1, 1, ssz(ngs) });
		if (i < ssz(tr[id]) - 1)
		{
			int y = tr[id][i + 1];
			mergef(x, y, lsf, ilsf);
		}
		lsf = 1ll * lsf * ff[x] % mod, ilsf = 1ll * ilsf * ifac[x + 1] % mod * fac[x] % mod;
	}
	if (ssz(tr[id]) > 1)
	{
		int y = tr[id][1];
		// cerr << lsf << " " << ilsf << " " << 1ll * lsf * ilsf % mod << endl;
		if (lsf)
			tg.imu = 1ll * tg.imu * ilsf % mod;
		// cerr << ssz(gs) << " " << ssz(fs[y]) << endl;
		for (int j = 0, k = ssz(gs) - (l - ssz(fs[y])); k >= 0 && j < ssz(fs[y]); j++, k--)
			if (k < ssz(gs))
			{
				// cerr << id << " " << k << " " << recvg(gs[k].first, k, tg) << " " << recv(y, j) << endl;
				int cv = 1ll * recvg(gs[k].first, k, tg) * recv(y, j) % mod;
				gs[k].first = 1ll * (cv - 1ll * tg.ad * lsf % mod + mod) * tg.imu % mod;
				// cerr << gs[k].first << " " << recvg(gs[k].first, k, tg) << endl;
			}
	// cerr << gs.back().first << " " << recvg(gs.back().first, ssz(gs) - 1, tg) << endl;
		tg.ad = 1ll * tg.ad * lsf % mod;
		if (lsf)
			tg.mu = 1ll * tg.mu * lsf % mod;
		else
		{
			// cerr << "? " << ssz(fs[y]) << " " << ssz(gs) << endl;
			int dv = ssz(gs) + ssz(fs[y]) - l;
			for (int i = max(0, ssz(gs) - l + 1); i < dv && i < ssz(gs); i++)
				gs[i].first = recvg(gs[i].first, i, tg);
			tg = { 1, 1, 0, dv };
		}
	}
	if (ssz(gs) >= l)
		end(gs)[-l].first = 1ll * (1 - tg.ad + mod) * tg.imu % mod;
	(tg.ad += 1) %= mod;
	// cerr << gs.back().first << " " << recvg(gs.back().first, ssz(gs) - 1, tg) << endl;
	
	dfs2(tr[id][0], gs, tg);
}

signed main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);
	
	int n, k;
	
	cin >> n >> l >> k;
	fill(hd, hd + n, -1);
	for (int i = 1, x, y; i < n; i++)
	{
		cin >> x >> y, x--, y--;
		add(x, y), add(y, x);
	}
	dfs0(0, -1);
	
	for (int i = n - 1; i >= 0; i--)
		for (auto [p, x] : buc[i])
		{
			// cerr << p << " --> " << x << endl;
			tr[p].emplace_back(x);
		}
	
	fac[0] = 1;
	for (int i = 0; i < n; i++)
		fac[i + 1] = 1ll * fac[i] * (ff[i] ? ff[i] : 1) % mod;
	ifac[n] = qpow(fac[n], mod - 2);
	for (int i = n; i > 0; i--)
		ifac[i - 1] = 1ll * ifac[i] * (ff[i - 1] ? ff[i - 1] : 1) % mod;
	
	dfs1(0);
	vector<pair<int, int>> gs(mxd[0]);
		for (int y = 0, j = ssz(gs) - 1; y != -1; y = tr[y].empty() ? -1 : tr[y][0], j--)
			gs[j] = { 1, y };
	dfs2(0, gs, { 1, 1, 0, ssz(gs) });
	int ans = 0;
	for (int i = 0; i < n; i++)
		ans = (ans + qpow(1ll * (f[i] - 1 + mod) * g[i] % mod, k)) % mod;
	if (l > 0)
	{
		for (int i = 1; i < n; i++)
			ans = (ans - qpow(1ll * (f2[i] - 1 + mod) * (g[i] - 1 + mod) % mod, k) + mod) % mod;
	}
	cout << ans << endl;
	
	return 0;
}
/*#include <algorithm>
#include <stdio.h>
#include <vector>
typedef long long llt;
typedef unsigned uint;typedef unsigned long long ullt;
typedef bool bol;typedef char chr;typedef void voi;
typedef double dbl;
template<typename T>bol _max(T&a,T b){return(a<b)?a=b,true:false;}
template<typename T>bol _min(T&a,T b){return(b<a)?a=b,true:false;}
template<typename T>T lowbit(T n){return n&-n;}
template<typename T>T gcd(T a,T b){return b?gcd(b,a%b):a;}
template<typename T>T lcm(T a,T b){return(a!=0||b!=0)?a/gcd(a,b)*b:(T)0;}
template<typename T>T exgcd(T a,T b,T&x,T&y){if(b!=0){T ans=exgcd(b,a%b,y,x);y-=a/b*x;return ans;}else return y=0,x=1,a;}
template<typename T>T power(T base,T index,T mod)
{
    T ans=1%mod;
    while(index)
    {
        if(index&1)ans=ans*base%mod;
        base=base*base%mod,index>>=1;
    }
    return ans;
}
namespace ConstMod
{
    template<const ullt p>
    class mod_ullt
    {
        private:
            ullt v;
            inline ullt chg(ullt w){return(w<p)?w:w-p;}
            inline mod_ullt _chg(ullt w){mod_ullt ans;ans.v=(w<p)?w:w-p;return ans;}
        public:
            mod_ullt():v(0){}
            mod_ullt(ullt v):v(v%p){}
            bol empty(){return!v;}
            inline ullt val(){return v;}
            friend bol operator<(mod_ullt a,mod_ullt b){return a.v<b.v;}etVal[2][i])^k;
    for(uint i=1;i<n;i++)ans-=(GetVal[1][i]*(GetVal[2][i]-1))^k;
    ans.println();
    return 0;
}*/