//EK ONKAR
#include <bits/stdc++.h>

using namespace std;

/******************************MACROS******************************/

#define int long long
#define ld long double
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define yes cout<<"Yes\n"
#define no cout<<"No\n"
#define vt vector
#define pb push_back
#define F first
#define S second
#define u_s unordered_set
#define u_m unordered_map
#define p_q priority_queue
#define m_p make_pair

/******************************TEMPLATE******************************/

#define sim template < class c
#define ris return * this
#define dor > debug & operator <<
#define eni(x) sim > typename \
  enable_if<sizeof dud<c>(0) x 1, debug&>::type operator<<(c i) {
sim > struct rge { c b, e; };
sim > rge<c> range(c i, c j) { return rge<c>{i, j}; }
sim > auto dud(c* x) -> decltype(cerr << *x, 0);
sim > char dud(...);
struct debug {
#ifndef ONLINE_JUDGE
    ~debug() { cerr << endl; }
    eni(!=) cerr << boolalpha << i; ris; }
    eni(==) ris << range(begin(i), end(i)); }
    sim, class b dor(pair < b, c > d) {
        ris << "(" << d.first << ", " << d.second << ")";
    }
    sim dor(rge<c> d) {
        *this << "[";
        for (auto it = d.b; it != d.e; ++it)
            *this << ", " + 2 * (it == d.b) << *it;
        ris << "]";
    }
#else
    sim dor(const c&) { ris; }
#endif
};
#define deb(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "

/******************************ALGORITHMS******************************/

int __pow(int x, int y, int M) {int res = 1;while(y>0){if(y&1) res = (res*x)%M; y>>=1; x = (x*x)%M;}return res%M;}
int __pow(int x, int y) {int res = 1;while(y>0){if(y&1) res = (res*x); y>>=1; x = (x*x);}return res;}
int mi(int x, int M) {return __pow(x, M-2, M);}
int gcd(int a, int b) {if(b==0) return a; return gcd(b, a % b);}
int add(int a, int b, int M) {return (a+b) % M;}
int mul(int a, int b, int M) {return (a*b) % M;}
int sub(int a, int b, int M) {return (a-b+M) % M;}
int div(int a, int b, int M) {return (a*mi(b, M)) % M;}
void umax(int &a, int b) {a = max(a, b);}
void umin(int &a, int b) {a = min(a, b);}

/******************************main*code******************************/

const int N = 5e3+2, inf = 1e18, M = 998244353;

int Test, n, m, k, dp[N][N];
bool ok = 1;
vt<int> g[N];

void dfs(int u, int par = 0)
{
    bool is_leaf = 1;
    for(auto v:g[u]) if(v != par)
        {
            dfs(v, u);
            is_leaf = 0;
        }
    if(is_leaf)
    {
        for(int j = 0; j<=k; j++)
            dp[u][j] = 1;
        return;
    }
    for(int j = 0; j<=k/2; j++)
    {
        dp[u][j] = 1;
        for(auto v:g[u]) if(v != par)
                dp[u][j] = (dp[u][j] * ((j == 0 ? 0 : dp[v][j-1]) + dp[v][k])) % M;
    }
    for(int j = k/2 + 1; j<=k; j++)
    {
        int last = 1;
        int i = 1;
        dp[u][j] = 0;
        for(auto v:g[u]) if(v != par)
            {
                int tmp = last;
                last = (tmp * (dp[v][k] + (j == k ? 0 : dp[v][k-j-1]))) % M;
                dp[u][j] = ((tmp * (j == 1 ? dp[v][j-1] : (dp[v][j-1] - dp[v][j-2] + M) % M)) % M + (dp[u][j] * (dp[v][k] + (j == k ? 0 : dp[v][k-j-1]))) % M) % M;
                i++;
            }
        dp[u][j] = (dp[u][j-1] + dp[u][j]) % M;
    }
}

void test_case()
{
    cin >> n >> k;
    g[1].pb(0);
    for(int i = 1; i<n; i++)
    {
        int u, v;
        cin >> u >> v;
        g[u].pb(v);
        g[v].pb(u);
    }
    dfs(1);
    cout << dp[1][k] << endl;
}

int32_t main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    Test = 1;
    //cin >> Test;
    while(Test--)
        test_case();
#ifndef ONLINE_JUDGE
    cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s." << endl;
#endif
    return 0;
}
