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

inline void add_mod(int &a, int b) {
    a += b;

    if (a >= mod)
        a -= mod;
}

inline ll pw(ll a, ll b) {
    ll res = 1;

    while (b) {
        if (b & 1)
            res = res * a % mod;

        a = a * a % mod;
        b >>= 1;
    }

    return res;
}

struct Segment_Tree {
    int tagm[MAXN << 2], taga[MAXN << 2];
#define ls(u) ((u)<<1)
#define rs(u) ((u)<<1|1)
#define lson(u) ls(u),l,mid
#define rson(u) rs(u),mid+1,r
    inline void upd_tagm(int u, int k) {
        tagm[u] = (ll)tagm[u] * k % mod;
        taga[u] = (ll)taga[u] * k % mod;
    }
    inline void upd_taga(int u, int k) {
        add_mod(taga[u], k);
    }
    inline void push_down(int u) {
        if (tagm[u] != 1) {
            upd_tagm(ls(u), tagm[u]);
            upd_tagm(rs(u), tagm[u]);
            tagm[u] = 1;
        }

        if (taga[u]) {
            upd_taga(ls(u), taga[u]);
            upd_taga(rs(u), taga[u]);
            taga[u] = 0;
        }
    }
    void update_mul(int u, int l, int r, int ql, int qr, int k) {
        if (ql <= l && r <= qr) {
            upd_tagm(u, k);
            return;
        }

        push_down(u);
        int mid = (l + r) >> 1;

        if (ql <= mid)
            update_mul(lson(u), ql, qr, k);

        if (mid < qr)
            update_mul(rson(u), ql, qr, k);
    }
    void update_add(int u, int l, int r, int ql, int qr, int k) {
        if (ql <= l && r <= qr) {
            upd_taga(u, k);
            return;
        }

        push_down(u);
        int mid = (l + r) >> 1;

        if (ql <= mid)
            update_add(lson(u), ql, qr, k);

        if (mid < qr)
            update_add(rson(u), ql, qr, k);
    }
    int get(int u, int l, int r, int q) {
        if (l == r)
            return taga[u];

        push_down(u);
        int mid = (l + r) >> 1;
        return q <= mid ? get(lson(u), q) : get(rson(u), q);
    }

    int n;
    void update_mul(int ql, int qr, int k) {
        if (ql <= qr)
            update_mul(1, 0, n, ql, qr, k);
    }
    void update_add(int ql, int qr, int k) {
        if (ql <= qr)
            update_add(1, 0, n, ql, qr, k);
    }
    int get(int q) {
        return get(1, 0, n, q);
    }
} trU, trD;

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

int dep[MAXN], h[MAXN], son[MAXN];
void dfs_tree(int u, int fa) {
    if (fa)
        g[u].erase(find(g[u].begin(), g[u].end(), fa));

    for (int v : g[u])
        if (v != fa) {
            dep[v] = dep[u] + 1;
            dfs_tree(v, u);

            if (son[u] == 0 || h[v] > h[son[u]])
                son[u] = v;

            h[u] = max(h[u], h[v] + 1);
        }
}

int dfn[MAXN], seq[MAXN], top[MAXN], curdfn = 0;
void dfs_dfn(int u, int tp) {
    top[u] = tp;
    dfn[u] = ++curdfn;
    seq[curdfn] = u;

    if (son[u])
        dfs_dfn(son[u], tp);

    for (int v : g[u])
        if (v != son[u])
            dfs_dfn(v, v);
}

int f1[MAXN], f2[MAXN], f3[MAXN];

void merge_trU(int u, int type) {
    if (type == 1) {
        trU.update_add(dfn[u], dfn[u] + h[u], 1);

        for (int v : g[u])
            if (v != son[u]) {
                for (int i = 0; i <= h[v]; ++i)
                    trU.update_mul(dfn[u] + i + 1, dfn[u] + i + 1, (trU.get(dfn[v] + i) + 1) % mod);

                trU.update_mul(dfn[u] + h[v] + 2, dfn[u] + h[u], (trU.get(dfn[v] + h[v]) + 1) % mod);
            }
    } else {
        for (int v : g[u])
            if (v != son[u]) {
                for (int i = 0; i <= h[v]; ++i)
                    trU.update_mul(dfn[u] + i + 1, dfn[u] + i + 1, pw((trU.get(dfn[v] + i) + 1) % mod, mod - 2));

                trU.update_mul(dfn[u] + h[v] + 2, dfn[u] + h[u], pw((trU.get(dfn[v] + h[v]) + 1) % mod, mod - 2));
            }

        trU.update_add(dfn[u], dfn[u] + h[u], mod - 1);
    }
}

void dfs_trU(int u) {
    for (int v : g[u])
        dfs_trU(v);

    merge_trU(u, 1);

    f1[u] = trU.get(dfn[u] + min(h[u], d));
    f2[u] = d != 0 ? trU.get(dfn[u] + min(h[u], d - 1)) : 0;
}

void dfs_trD(int u) {
    merge_trU(u, -1);

    int secmx = 0;

    for (int v : g[u])
        if (v != son[u])
            secmx = max(secmx, h[v] + 1);

    f3[u] = trD.get(dep[u]);

    auto upd = [&](int v, int type) {
        int cur = v == son[u] ? secmx : h[u];
        int l = d - 1 - cur, r = d - 2;
        l = max(l, 0);

        if (l > r)
            return;

        for (int i = l; i <= r && i <= h[v]; ++i) {
            int pos = dep[u] + (d - 1 - i);
            int k = (trU.get(dfn[v] + i) + 1) % mod;
            trD.update_mul(pos, pos, type == 1 ? k : pw(k, mod - 2));
        }

        if (h[v] + 1 <= r) {
            int pos = dep[u] + (d - 1 - h[v] - 1);
            int k = (trU.get(dfn[v] + h[v]) + 1) % mod;
            trD.update_mul(dep[u] + 1, pos, type == 1 ? k : pw(k, mod - 2));
        }
    };

    trD.update_add(dep[u] + 1, dep[u] + min(h[u], d), 1);

    for (int v : g[u])
        upd(v, 1);

    for (int v : g[u]) {
        upd(v, -1);
        dfs_trD(v);
        upd(v, 1);
    }

    for (int v : g[u])
        upd(v, -1);

    trD.update_add(dep[u] + 1, dep[u] + h[u], mod - 1);

    merge_trU(u, 1);
}

int main(void) {
    int m;
    scanf("%d%d%d", &n, &d, &m);

    for (int i = 1; i < n; ++i) {
        int u, v;
        scanf("%d%d", &u, &v);
        g[u].push_back(v);
        g[v].push_back(u);
    }

    dfs_tree(1, 0);
    dfs_dfn(1, 1);

    trU.n = trD.n = n;
    dfs_trU(1);
    dfs_trD(1);

    // for(int u=1; u<=n; ++u)
    // {
    //  printf("f[%d] = {%d, %d, %d}\n",u,f1[u],f2[u],f3[u]);
    // }

    ll ans1 = 0, ans2 = 0;

    for (int i = 1; i <= n; ++i) {
        ans1 = (ans1 + pw((ll)f1[i] * (f3[i] + 1) % mod, m)) % mod;
        ans2 = (ans2 + pw((ll)f2[i] * f3[i] % mod, m)) % mod;
    }

    ll ans = (ans1 - ans2 + mod) % mod;

    printf("%lld\n", ans);
    return 0;
}